Opening a URL is one of the most fundamental operations in Selenium WebDriver. After launching a browser, Selenium allows us to navigate to a specific web address and load the requested web page automatically. This operation is commonly used as the first step in Selenium automation because most test scenarios begin by opening an application, website, login page, dashboard, or any other web resource.
In Selenium WebDriver, the get() method is commonly used to navigate the browser to a fully qualified URL. The driver.get(url) command is used to navigate the browser to the specified URL.
Opening a URL in Selenium means instructing the automated browser to navigate to a particular web address. Instead of manually typing a URL into the browser address bar, Selenium sends a navigation command to the browser through WebDriver.
For example, if we want to open Google, we can use:
driver.get("https://www.google.com");When Selenium executes this statement, the browser navigates to the specified address.
A URL normally contains a protocol such as https:// followed by the domain name and, optionally, a path, query parameters, or fragments.
Opening a URL is required before Selenium can interact with most web application elements. A typical automation test begins by launching the browser and navigating to the application under test.
For example, a login test may follow this sequence:
Launch Browser
↓
Open Application URL
↓
Load Login Page
↓
Find Username Field
↓
Enter Username
↓
Enter Password
↓
Click Login
↓
Verify Dashboard
Therefore, URL navigation forms an important part of the initial setup of many Selenium test cases.
In Selenium Java, the basic syntax is:
driver.get("URL");Example:
driver.get("https://www.google.com");Here:
| Component | Meaning |
|---|---|
| driver | The WebDriver object controlling the browser. |
| get() | The WebDriver method used to navigate to a URL. |
| URL | The web address that should be opened. |
Before opening a URL, a Selenium test generally needs a valid WebDriver session. WebDriver provides the interface used to control browsers, with browser-specific driver implementations handling communication between Selenium and the browser.
The basic requirements are:
Normally, we first create a browser driver and then open the required URL.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class OpenURL {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.quit();
}
}
The statement:
WebDriver driver = new ChromeDriver();creates a Chrome browser session, while:
driver.get("https://www.google.com");navigates that browser session to Google.
The get() method is one of the most frequently used WebDriver methods. Selenium's Java API defines get(String url) as loading a new web page in the current browser window. It is also documented as a synonym for the navigation to() method.
Syntax:
driver.get("https://example.com");Example:
WebDriver driver = new ChromeDriver();
driver.get("https://www.selenium.dev");
The browser will navigate to the specified Selenium website.
The URL supplied to WebDriver should normally include its protocol, such as http:// or https://. The URL supplied to get() should be a complete web address.
Correct:
driver.get("https://www.google.com");Another correct example:
driver.get("http://example.com");Avoid using an incomplete address such as:
driver.get("www.google.com");Always prefer a complete URL:
driver.get("https://www.google.com");Suppose we want to open the Selenium website.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class SeleniumWebsite {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.selenium.dev");
driver.quit();
}
}
The execution flow is:
Start Java Program
↓
Create ChromeDriver
↓
Start Chrome Browser
↓
Execute driver.get()
↓
Navigate to Selenium Website
↓
Perform Test Actions
↓
driver.quit()
↓
Close Browser Session
In real-world automation, the URL is often a login page.
driver.get("https://example.com/login");After the page loads, Selenium can locate the login fields and interact with them.
driver.get("https://example.com/login");
driver.findElement(By.id("username")).sendKeys("admin");
driver.findElement(By.id("password")).sendKeys("admin123");
driver.findElement(By.id("login")).click();
The URL navigation is therefore the starting point of the login automation flow.
A URL does not have to point only to the home page. Selenium can open a specific application page.
driver.get("https://example.com/products");Another example:
driver.get("https://example.com/dashboard");Another example:
driver.get("https://example.com/contact");This is useful when a test needs to start directly from a particular application module.
URLs can contain query parameters.
For example:
driver.get("https://example.com/search?q=selenium");Here, q=selenium is a query parameter.
Another example:
driver.get("https://example.com/products?category=mobile");Selenium can navigate to such URLs in the same way as other fully qualified URLs.
A URL can contain a path that identifies a particular resource or page.
driver.get("https://example.com/products/mobile/iphone");This allows an automation test to directly navigate to the required page without manually navigating through several menus.
Selenium can navigate to multiple URLs sequentially during the same browser session.
driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.get("https://example.com");
The browser will navigate from one URL to the next in the order in which the commands are executed.
The final URL in this example will be:
https://example.comAfter opening a URL, Selenium can retrieve information about the current page. For example, the page title can be retrieved using getTitle().
WebDriver driver = new ChromeDriver();
driver.get("https://www.selenium.dev");
String title = driver.getTitle();
System.out.println(title);
driver.quit();
Selenium automation commonly uses the page title and current URL to verify that the expected page has been opened.
After navigation, we can retrieve the URL of the current page using getCurrentUrl().
driver.get("https://www.selenium.dev");
String currentUrl = driver.getCurrentUrl();
System.out.println(currentUrl);
This can be useful for validating whether navigation was successful.
A simple validation can compare the current URL with the expected URL.
driver.get("https://www.selenium.dev");
String actualUrl = driver.getCurrentUrl();
String expectedUrl = "https://www.selenium.dev";
if (actualUrl.equals(expectedUrl)) {
System.out.println("URL matched");
} else {
System.out.println("URL did not match");
}
This type of validation is useful in navigation-related test cases.
Selenium also provides a navigation interface through driver.navigate().to().
driver.navigate().to("https://www.google.com");The navigate() interface provides browser navigation operations, including navigation to a URL, back, forward, and refresh.
| get() | navigate().to() |
|---|---|
| Used to open a URL. | Also used to navigate to a URL. |
| Simple and commonly used. | Part of Selenium's Navigation interface. |
| Syntax: driver.get(url) | Syntax: driver.navigate().to(url) |
| Very common in basic test scripts. | Useful when working with navigation operations such as back and forward. |
Example:
driver.get("https://www.google.com");Equivalent navigation form:
driver.navigate().to("https://www.google.com");Once a URL has been opened, Selenium provides navigation operations such as back, forward, and refresh.
driver.get("https://www.google.com");
driver.get("https://www.selenium.dev");
driver.navigate().back();
driver.navigate().forward();
driver.navigate().refresh();
This creates a simple browser navigation flow:
Google
↓
Selenium
↓
Back
↓
Google
↓
Forward
↓
Selenium
↓
Refresh
Chrome is one of the commonly used browsers for Selenium automation.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class ChromeURL {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.quit();
}
}
The same concept can be used with Firefox.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
public class FirefoxURL {
public static void main(String[] args) {
WebDriver driver = new FirefoxDriver();
driver.get("https://www.google.com");
driver.quit();
}
}
Microsoft Edge can also be controlled using Selenium.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.edge.EdgeDriver;
public class EdgeURL {
public static void main(String[] args) {
WebDriver driver = new EdgeDriver();
driver.get("https://www.google.com");
driver.quit();
}
}
The basic architecture can be represented as:
Java Test Code
↓
WebDriver API
↓
Browser Driver
↓
Browser
↓
Requested URL
↓
Web Page
Selenium WebDriver provides a language-neutral interface for controlling browsers, while browser-specific drivers communicate with the corresponding browser.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class OpenWebsite {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
System.out.println("Page Title: " + driver.getTitle());
System.out.println("Current URL: " + driver.getCurrentUrl());
driver.quit();
}
}
This example performs the following operations:
Instead of hardcoding a URL directly inside get(), we can store it in a variable.
String url = "https://www.google.com";
driver.get(url);
This approach becomes useful when URLs are read from configuration files, environment variables, test data, or other external sources.
In larger automation frameworks, URLs are often maintained outside the test code.
For example, a configuration file may contain:
baseUrl=https://example.comThe test framework can read this value and pass it to WebDriver.
String baseUrl = "https://example.com";
driver.get(baseUrl);
This makes it easier to change environments such as development, QA, staging, and production.
Real-world applications may have different URLs for different environments.
| Environment | Example URL |
|---|---|
| Development | https://dev.example.com |
| QA | https://qa.example.com |
| Staging | https://staging.example.com |
| Production | https://www.example.com |
The same Selenium test can potentially be executed against different environments by changing the base URL configuration.
A common beginner mistake is trying to locate elements before navigating to the required page.
Correct sequence:
driver.get("https://example.com/login");
driver.findElement(By.id("username"));
Instead of attempting to find login elements before opening the login page.
The general sequence is:
Launch Browser
↓
Open URL
↓
Wait for Page State
↓
Locate Element
↓
Perform Action
↓
Validate Result
Example:
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class SearchExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
driver.findElement(By.name("q"))
.sendKeys("Selenium WebDriver");
driver.findElement(By.name("q"))
.submit();
driver.quit();
}
}
This demonstrates how URL navigation becomes the first step before interacting with page elements.
A typical login automation flow may look like:
driver.get("https://example.com/login");
driver.findElement(By.id("username"))
.sendKeys("testuser");
driver.findElement(By.id("password"))
.sendKeys("password123");
driver.findElement(By.id("loginButton"))
.click();
The URL navigation is performed first, followed by element interactions.
driver.get("https://www.selenium.dev");
String title = driver.getTitle();
System.out.println("Title: " + title);
In an actual test framework, the title can be compared with an expected value using an assertion.
String expectedTitle = "Selenium";
String actualTitle = driver.getTitle();
if (actualTitle.contains(expectedTitle)) {
System.out.println("Title verification passed");
} else {
System.out.println("Title verification failed");
}
driver.get("https://www.selenium.dev");
String expectedUrl = "https://www.selenium.dev/";
String actualUrl = driver.getCurrentUrl();
System.out.println("Expected URL: " + expectedUrl);
System.out.println("Actual URL: " + actualUrl);
Remember that a website can redirect from one URL to another, so the final current URL may not always be textually identical to the initially requested URL.
Web applications can redirect users from one URL to another. For example:
driver.get("https://example.com");The application may redirect the browser to:
https://www.example.com/Therefore, when validating navigation, it can be useful to check the final current URL using:
driver.getCurrentUrl();The get() method navigates the browser to the requested page according to the configured WebDriver page-load strategy.
Basic example:
driver.get("https://example.com");After navigation, Selenium can continue with further commands according to the state of the page and the synchronization strategy used by the test.
In headless execution, the browser runs without displaying a normal graphical browser window. This is frequently useful in automated environments and CI/CD systems.
Example using ChromeOptions:
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
public class HeadlessURL {
public static void main(String[] args) {
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
WebDriver driver = new ChromeDriver(options);
driver.get("https://www.google.com");
System.out.println(driver.getTitle());
driver.quit();
}
}
After opening the browser, the window can be maximized.
driver.manage().window().maximize();
driver.get("https://www.google.com");
Another common sequence is:
WebDriver driver = new ChromeDriver();
driver.manage().window().maximize();
driver.get("https://www.google.com");
After navigating to a URL, Selenium can be used together with the screenshot API to capture the current browser state.
driver.get("https://www.google.com");
File screenshot = ((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
This is useful for debugging failed tests and documenting test execution.
URL navigation is frequently performed inside a TestNG test or setup method.
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class URLTest {
WebDriver driver;
@BeforeMethod
public void setUp() {
driver = new ChromeDriver();
}
@Test
public void openURL() {
driver.get("https://www.google.com");
System.out.println(driver.getTitle());
}
@AfterMethod
public void tearDown() {
driver.quit();
}
}
In a Page Object Model framework, the navigation URL is often handled through a page object or base test configuration.
public class LoginPage {
WebDriver driver;
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void openLoginPage() {
driver.get("https://example.com/login");
}
}
The test can then call:
LoginPage loginPage = new LoginPage(driver);
loginPage.openLoginPage();
A browser factory can centralize browser creation.
public class BrowserFactory {
public static WebDriver createDriver() {
return new ChromeDriver();
}
}
The test can then use:
WebDriver driver = BrowserFactory.createDriver();
driver.get("https://example.com");
This design becomes useful when a framework supports multiple browsers.
The same URL can be opened in different browsers.
WebDriver driver;
driver = new ChromeDriver();
driver.get("https://example.com");
driver.quit();
driver = new FirefoxDriver();
driver.get("https://example.com");
driver.quit();
driver = new EdgeDriver();
driver.get("https://example.com");
driver.quit();
Selenium supports automation across major browsers through WebDriver implementations.
driver.get("www.google.com");Use a complete URL:
driver.get("https://www.google.com");Calling:
driver.get("https://example.com");before creating the WebDriver instance will not work.
Correct:
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
If the browser session cannot be created because of an environment or driver configuration problem, URL navigation cannot begin.
If the machine cannot access the requested website, the navigation may fail or the page may not load as expected.
A real-world Selenium automation framework may follow this architecture:
Test Case
↓
Test Configuration
↓
Browser Factory
↓
Create WebDriver
↓
Open Base URL
↓
Page Object
↓
Find Elements
↓
Perform Actions
↓
Assertions
↓
Test Report
↓
Quit Browser
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class CompleteURLExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://www.google.com");
System.out.println("Title: " + driver.getTitle());
System.out.println("Current URL: " + driver.getCurrentUrl());
driver.findElement(By.name("q"))
.sendKeys("Selenium WebDriver");
driver.findElement(By.name("q"))
.submit();
System.out.println("Search completed");
} finally {
driver.quit();
}
}
}
This example demonstrates a practical flow of launching the browser, opening a URL, retrieving browser information, interacting with a web element, and finally terminating the browser session.
Project Objective: Create a Selenium program that opens a website and verifies its title and current URL.
WebDriver driver = new ChromeDriver();driver.get("https://www.selenium.dev");String title = driver.getTitle();String url = driver.getCurrentUrl();System.out.println("Title: " + title);
System.out.println("URL: " + url);
driver.quit();import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class WebsiteValidation {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://www.selenium.dev");
String title = driver.getTitle();
String currentUrl = driver.getCurrentUrl();
System.out.println("Page Title: " + title);
System.out.println("Current URL: " + currentUrl);
if (currentUrl.contains("selenium.dev")) {
System.out.println("URL validation passed");
} else {
System.out.println("URL validation failed");
}
} finally {
driver.quit();
}
}
}
In a professional Selenium framework, URL navigation is generally part of the test setup or page navigation layer rather than being repeated unnecessarily throughout every test.
For example:
public class BaseTest {
protected WebDriver driver;
public void setUp() {
driver = new ChromeDriver();
driver.get("https://example.com");
}
public void tearDown() {
driver.quit();
}
}
Individual tests can then begin from a known application state.
Page Object Model can encapsulate page navigation.
public class HomePage {
private WebDriver driver;
public HomePage(WebDriver driver) {
this.driver = driver;
}
public void open() {
driver.get("https://example.com");
}
public String getPageTitle() {
return driver.getTitle();
}
}
This approach keeps navigation-related code organized and reusable.
Opening a URL and validating the result are two separate activities.
driver.get("https://example.com");
String actualUrl = driver.getCurrentUrl();
Assert.assertTrue(actualUrl.contains("example.com"));
The first statement performs navigation, while the second validates the resulting browser state.
| Opening URL | Clicking Link |
|---|---|
| Uses driver.get() or navigation methods. | Uses WebElement.click(). |
| Directly navigates to a specified address. | Simulates a user clicking a link. |
| Useful for direct navigation. | Useful for testing actual UI navigation. |
Example of direct URL navigation:
driver.get("https://example.com/products");Example of link navigation:
driver.findElement(By.linkText("Products")).click();Application Test
↓
Selenium WebDriver API
↓
Navigation Command
↓
Browser Driver
↓
Browser
↓
HTTP/HTTPS Request
↓
Web Server
↓
Web Page Response
↓
Browser Renders Page
The Selenium WebDriver API provides the commands used by the automation code, while the browser and its driver handle the actual browser-level communication.
Modern Selenium releases include Selenium Manager, which can assist with browser-driver management. Selenium Manager can automatically handle browser driver installation in supported Selenium workflows.
For example, modern Selenium Java code can commonly start a Chrome session using:
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
The exact environment requirements can still depend on the installed browser, Selenium version, operating system, and project configuration.
Answer: We can use the get() method of WebDriver.
driver.get("https://www.google.com");The method navigates the current browser window to the specified URL.
Answer: driver.get() is a WebDriver method used to navigate the browser to a specified URL.
driver.get("https://example.com");The method loads a new web page in the current browser window.
Answer: Both can be used to navigate to a URL. The get() method provides a simple direct API, while navigate() provides the browser navigation interface, including operations such as back, forward, refresh, and navigation to a URL.
Answer: Selenium can navigate to web URLs that the browser and test environment can access, provided the URL is valid and appropriately formatted. The URL should normally include its protocol such as https:// or http://.
Answer: Use getCurrentUrl().
String currentUrl = driver.getCurrentUrl();
System.out.println(currentUrl);
This method retrieves the URL of the current page.
| Concept | Syntax |
|---|---|
| Create Chrome browser | WebDriver driver = new ChromeDriver(); |
| Open URL | driver.get("https://example.com"); |
| Navigate to URL | driver.navigate().to("https://example.com"); |
| Get page title | driver.getTitle(); |
| Get current URL | driver.getCurrentUrl(); |
| Go back | driver.navigate().back(); |
| Go forward | driver.navigate().forward(); |
| Refresh page | driver.navigate().refresh(); |
| Close browser session | driver.quit(); |
Start Test
↓
Create WebDriver
↓
Launch Browser
↓
Prepare Fully Qualified URL
↓
driver.get(URL)
↓
Browser Navigates
↓
Page Loads
↓
Get Title / Current URL
↓
Find Elements
↓
Perform Actions
↓
Validate Result
↓
driver.quit()
↓
End Test
After completing this topic, you should be able to:
For structured Selenium Automation Testing training, you can explore the JustAcademy Selenium training course:
JustAcademy Selenium Automation Testing Course
You can also register for a course demo using the following link:
Register for Selenium Course Demo
Opening a URL is one of the first and most important operations performed in Selenium WebDriver automation. After creating a WebDriver session, the test can use driver.get() to navigate the browser to a fully qualified URL. Selenium also provides the navigation interface through driver.navigate().to(), along with browser-history operations such as back, forward, and refresh.
A typical Selenium workflow is:
WebDriver driver = new ChromeDriver();
driver.get("https://example.com");
System.out.println(driver.getTitle());
System.out.println(driver.getCurrentUrl());
driver.quit();
Understanding URL navigation provides the foundation for more advanced Selenium operations such as locating elements, performing clicks, entering data, handling forms, validating pages, implementing Page Object Model frameworks, performing cross-browser testing, and building complete end-to-end automation frameworks.
